Graphical editor for program files

ABSTRACT

An editor for creating and editing user-guidance information employs multiple interrelated interfaces. One such interface allows the user to create a user-guidance sequence from a series of component script file module objects and panel display objects. Each object is assigned a graphical icon. The user constructs the sequence by stringing together the icons to implement the desired sequence. The user may maintain a customized file of frequently used component script files objects and panel display objects. The user may add an object from the customized file to a sequence currently being edited by “dragging” its associated icon from the file to the sequence. The user may perform editing on individual display objects within the above described sequence of display objects by “clicking” on one of the display objects. This invokes a separate editor which displays the contents of the display object. The editor operates on information in parse tree format.

This application is a continuation of application Ser. No. 08/644,413,filed May 10, 1996 now abandoned.

BACKGROUND OF THE DISCLOSURE

The present invention relates generally to graphical user interfaces forcomputer systems. More particularly, the present invention relates tomethods and systems for creating and editing program code which governsthe presentation of user guidance information.

The rapid advance of computer technology has enabled programmers togreatly enhance the sophistication of their software programs. Yet anincrease in sophistication often brings a increase in applicationcomplexity. Such complexity often serves to confuse and frustratecomputer users as they attempt to learn a new computer application,especially when the software manuals are large and burdensome to use.

The computer industry has attempted to address the above drawback bydesigning application programs with user-friendly display interfaces.Generally, the user-friendly paradigm aims to present information in thesimplest and most intuitive fashion possible. This may be achieved byorganizing information using a series of hierarchical menus or windows.Also, user-friendliness is promoted by including graphical metaphors inthe display interface instead of nondescriptive command-line prompts.For example, object-oriented display systems frequently employ images offile folders for storage of information, and graphical depictions oftrash containers for disposal (e.g. deletion) of information.

Another way of assisting an unfamiliar operator in using a computerapplication has been through user guidance interfaces (e.g. “help”interfaces). Such interfaces allow a user to quickly obtain help whenunsure how to proceed at a particular juncture in the execution of aprogram. For example, a user can activate a help icon or menu entry whenconfused. The system may surmise the user's problem depending on theparticular point in the program at which the user has activated the helpfunction. Alternatively, the user may focus his inquiry by placing acursor over an icon, menu, file folder or display object, whereupon thesystem responds by displaying an explanation of the selected displayobject. Still more focused guidance can be obtained by tailoringdifferent help messages to different users. For instance, an expert at aparticular application might prefer not to be bothered with a lengthyuser guidance message. As such, only a cursory explanation is providedto the expert user. In contrast, a novice user might require arelatively large amount of information to successfully navigate throughthe application program. Accordingly, the help message given to thenovice user may be quite lengthy.

While the above user-interface techniques have greatly enhanced theenjoyment and ease of using complex application programs, developingintricate guidance files for each application has proven very timeconsuming and burdensome. For example, the guidance files for the Applefamily of computers relies on the generation of script files. “Script”is textual high-level program code, usually developed using a wordprocessor or special script editor. User guidance information is oftenhighly repetitive; one program module may employ virtually the samemessages as another program module. Hence, the program designer has beenforced to tediously duplicate the same script for each separate module.Even when “cut” and “paste” editing commands are employed, the task ofcreating script is still burdensome.

Further, translating and compiling the word processor's script languagetakes a considerable amount of time. It is especially cumbersome tore-translate the entire source file every time a revision is made in thesource program. This difficulty is compounded by the fact that thetranslators and compilers sometimes produce errors. According to knowntechniques, the occurrence of an error typically causes the user torecompile the entire source file.

Accordingly, it would be desirable to produce a graphical interfacewhich is user-friendly to the program designer as well as the end user.

It is more particularly an exemplary object of the present invention toprovide an editor of guidance information which relies less on themanual creation and translation of textual script.

SUMMARY

These and other exemplary advantageous features are achieved through agraphical editor for creating user guidance programs. The editor employsa database of user guidance program modules, each of which is associatedwith a component of a guidance display program. The editor allows theuser to create and edit user guidance programs by selecting andaggregating different computer program modules. In this manner, the useris required to perform less editing on script text itself. In otherwords, the user can manipulate the program in units of program modulesinstead of individual lines of text script.

According to another exemplary aspect of the present invention, eachuser maintains a customized file of frequently used program modules.Each program module has a graphical icon associated therewith. The usercreates a computer program sequence by selecting modules from acustomized file and moving the modules to a sequence editor interface.At the sequence interface the user aggregates and arranges the modulesto define the desired program function. The movement of modules from thecustomized file to the sequence editor may be via a “drag-and-drop”procedure.

According to another exemplary embodiment of the present invention, thesequence editor displays a program sequence by showing a graphicalrepresentation of the interconnected program modules. The user can editindividual program modules within the above described sequence ofprogram modules by “clicking” on one of the program modules. Thisinvokes a separate editor which displays the contents of the programmodule. The user can then edit the displayed program module using theseparate editor interface. The separate editor may comprise a texteditor for modifying the text of a program module, a panel or accesseditor for editing the graphical layout of panels used in the deliveryof help information, and an index editor for editing words and phrasesused to access guidance information relating to a particular topic.

The different editors allow the user to review a script program in avariety of different representations. If a user makes modifications tothe script program in a particular representation, the system mayautomatically make corresponding changes in other representations. Forexample, if a user alters the script program using the graphicalrepresentation employed by the sequence editor, the system will makecorresponding changes to the individual lines of script code, which maybe reviewed using a text editor. In one embodiment, both graphical andtextual representations may be presented simultaneously on the graphicsdisplay. This allows the user to review, in real-time, how changes madein the sequence editor affect the text of the script program.

When the user is finished editing the computer program, the user closesout the editor(s), whereupon the system compiles any portion of thecomputer program which was modified. According to another beneficialaspect of the present invention, any errors detected in the compilingoperation are stored in association with a graphical icon. Clicking onthis icon after the end of compilation provides a display of theerroneous text, whereupon the user may make corrections and recompilethe corrected code.

The graphical editors of the present invention are designed to acceptprogram code in parse tree code format, and to output information in thesame parse tree format.

BRIEF DESCRIPTION OF THE DRAWINGS

The foregoing, and other, objects, features and advantages of thepresent invention will be more readily understood upon reading thefollowing detailed description in conjunction with the drawings inwhich:

FIG. 1 illustrates an exemplary computer system for implementing thepresent invention;

FIGS. 2-4 illustrate exemplary windows for accessing guidanceinformation using a “topics” search;

FIGS. 5-8 illustrate exemplary windows for accessing guidanceinformation using an “index” search;

FIGS. 9-10 illustrate exemplary windows for accessing guidanceinformation using a “look for” search;

FIGS. 11-12 illustrate the use of “coach marks” to highlightinstructions to a user;

FIG. 13 illustrates an exemplary conceptual layout of theinterrelationships between different display objects employed by thepresent invention;

FIG. 14 illustrates the guidance interface editor according to exemplaryaspects of the present invention;

FIGS. 15-16 illustrate the command editor interface according toexemplary aspects of the present invention;

FIG. 17 illustrates the sequence editor according to exemplarycharacteristics of the present invention;

FIG. 18 illustrates an icon for storing compiling errors;

FIG. 19 illustrates various files containing shortcut plug-ins fordifferent editors;

FIG. 20 illustrates various plug-in modules for insertion into thesequence representation illustrated in FIG. 15;

FIG. 21 illustrates an index editor summoned from the sequence editorinterface;

FIG. 22 illustrates the panel editor according to exemplary aspects ofthe present invention;

FIGS. 23-24 illustrate various aspects of the index editor according toexemplary characteristics of the present invention;

FIG. 25 illustrates an access window editor according to exemplaryaspects of the present invention;

FIG. 26 illustrates a localization tool window interface according toexemplary characteristics of the present invention;

FIGS. 27-30 illustrate exemplary parse code information generated by thecompiler of the present invention; and

FIGS. 31A-C illustrate the display of a script file in both textual andgraphical representations during an editing sequence.

DETAILED DESCRIPTION

In the following description, for purposes of explanation and notlimitation, specific details are set forth in order to provide athorough understanding of the invention. However it will be apparent toone of ordinary skill in the art that the present invention may bepracticed in other embodiments that depart from these specific details.In other instances, detailed descriptions of well-known methods,devices, and circuits are omitted so as not to obscure the descriptionof the present invention with unnecessary detail.

The computer controlled editor of the present invention may beimplemented by the exemplary computer system illustrated in FIG. 1. Thecomputer controlled display system includes a central processing unit(16) interconnected with memory (20) and I/O circuitry (12). The I/Ocircuitry, in turn, communicates with display monitor (26), mass memorydevice (e.g. 4), CD ROM (8), keyboard (48) and mouse (44). The mouse(44) includes one or more input means (40), such as one or more “clickbuttons” for inputting information into the computer system.Alternatively, the computer system may employ other input means, such asa joystick, graphic tablet or track-ball type of input device, as willbe apparent to one having ordinary skill in the art.

The CPU (16), in conjunction with program instructions received frommemories (4), (8) and/or (20), presents information on the display (26)using the well known window-based display paradigm. FIG. 1 shows atypical display presentation (28) including a window (36). Window (36)in turn includes a menu bar (32) disposed horizontally across the lengthof the window. Window bar (32) may include one or more “pull-down menus”(51). Movement of the mouse (44) may be translated by the computer intomovement of the cursor (52) on the display presentation (28).

The Macintosh series of computers sold by Apple Computer, Inc. may beused to implement the above functions. However, it should be apparentthat other commercially available computer systems may be used to carryout the present invention.

A. Guidance Interface

A.1 Overview

The advantageous features of the program editor of the present inventionmay be best appreciated by first discussing exemplary aspects of theguidance interface itself. One way of invoking the guidance interface ofthe present invention is through activation of an appropriate guidancerelated menu entry located in menu bar (32). For example, the menu bar(32) may include a pull down menu (51) including a menu entry entitled“help” associated with the guidance interface. “Clicking” on the “help”menu entry causes the generation of an access window (62) shown in FIG.2, which may be viewed as a central “portal” for obtaining guidanceinformation on various aspects of the computer system's operation. Amongother features, the guidance information may identify how a particularprogram feature operates, or may provide a series of tutorials designedto coach the user how to use a program feature in step-by-step fashion.

The access window (62) allows the operator to retrieve information usingthree different techniques: topic search, index search and “look for”search, each of which will be discussed below.

A.2 Topic Search

The topic search is activated by the user placing the cursor (52) overthe “topics” icon (64) and depressing the mouse button (40). The systemresponds by calling a series of topic titles from memory (4) or CD-ROM(8) and displaying them in the topic area (72). A user may select one ofthe titles within region (72) by scrolling a sliding bar (70) either upor down until he or she reaches a desired topic. In the specificembodiment of FIG. 2, the user has stopped at the title (70) reading“Files and disks”. Depressing the mouse button (40) while positioned atthis title causes CPU (16) to display a series of questions pertinent to“Files and Disks” at the right-hand column of the access window. Theuser may scroll through the right-hand list of questions via theright-hand scroll bar.

If the user finds an interrogatory which matches his own query, heplaces the cursor (52) over the relevant interrogatory, and pressesmouse button (40). For instance, in FIG. 3, the user has selected theinterrogatory “find a file or folder?”.

The user then finalizes the selection by clicking on the OK button (71)in the lower right-hand corner. This prompts the CPU (16) to display aninformation panel (74) relevant to the interrogatory, as illustrated inFIG. 4. As shown, the panel (74) effectively answers the user's query.

A.3 Index Search

The same information can be obtained by initially pressing the “index”icon (60) illustrated in FIG. 5. This causes the CPU to generate anindex screen (86) containing “index entries”. The index screen is headedby a horizontal alpha scroll bar (78). In operation, the user placescursor (52) over a desired letter and momentarily clicks the button (40)of the mouse. For example, in FIG. 6 the user has selected the letter“F” by positioning the cursor over the letter “F” and clicking themouse. Upon sensing the selection, the CPU (16) displays index entriesbeginning with the selected letter as illustrated in FIG. 6. Henceforth,the retrieval of additional information proceeds in the same mannerdiscussed before with regard to the topic search. For instance, the usermay scroll down through the list of index entries and select anappropriate topic. By clicking on the appropriate topic the CPU willgenerate a list of more refined questions (as illustrated in theright-hand column of FIG. 7). The user then selects an appropriatequestion within the right-hand column, as shown in FIG. 8. This willprompt the CPU (16) to generate the same information shown above in FIG.4.

A.4 Look For Search

Still another way of getting the same information is through the “lookfor” icon (56). Clicking on the “Look For” icon will generate a searchbox (87), as shown in FIG. 9. The user types in the search request (inthis case the word “file”) and then presses the search button (90). Thiscauses the CPU (16) to search the help database stored in memories (4)or (8) and return matching entries to working memory (20). The matchingentries are displayed on the right-hand side of the access window ofFIG. 10. The user-selects one of the matching entries, and then pressesthe OK button (71), once again generating the detailed instructionsshown in FIG. 4.

A.5 Coach Marks

Returning now to FIG. 4, suppose the user wanted to continue further inobtaining information about the topic “How do I find a file or folder”.If so, the user may click on one or more boxes in panel (74). This willcause the display of panels (110) and (126) shown in FIGS. 11 and 12,respectively. Note that these panels include graphical “coach marks”(106) and (118) respectively. The coach marks are designed to assist theuser in correlating the textual instructions in the help panels (114)and (99) with relevant portions of the application display interface.For instance, coach marks highlight features (102) and (122) in FIGS. 11and 12, respectively. Furthermore, the coach marks are not displayedsimultaneously with the generation of the help panel, but appear a shorttime after the help panel is displayed. This is designed to draw theuser's attention to the coach marks. To this end, the coach marks arealso in a freehand type of script, which further highlights the coachmarks from other display objects on the screen.

A.6 Internal Organization

Note from the preceding discussion that the panels relating to aspecific query were presented in specific order, referred to herein as a“sequence”. For example, as shown in FIG. 2, the questions “find a filefolder?”, “make an item easy to find?”, “find the original of analias?”, etc. in the right-hand display column may each comprise aseries of panels laid out in a specific order. Accordingly, each of thequestions may be regarded as a “sequence”.

The computer system preserves the interconnection between differentpanels by storing links to interrelated panels in a database (e.g. asstored in memories 4 and/or 8). The database may be conceptualized ashaving a plurality of component objects which are hierarchicallyordered, as illustrated in FIG. 13. As shown there, a parent panel maybe linked to several other child panels (as well as other displayobjects). And in turn, a panel itself may consist of many displayobjects which are hierarchically linked to the panel object. The panelobjects may include text objects, graphic objects, prompt objects,control objects, and qualifier objects. In a preferred embodiment,objects may be used by more than one other object (e.g. object 1130 inFIG. 13). For example, a single item of text data may be used bymultiple panels. This notion of re-use is one of the aspects of what iscommonly referred to as object-oriented programming

On a more global perspective, script files can be written which relatedifferent sequences together. For example, the user guidance file, whichconsists of a great multitude of different sequence definitions, may bebound by a script file which describes the interrelationship betweendifferent sequences, and the manner for navigating from one sequence toanother.

By way of simple illustration, consider the following script file:

<define sequence> “cow sequence”

-   -   <panel> “how now”    -   <panel> “brown cow”

<end sequence> #Cowabung

<define panel> “how now”

-   -   Hey Wow!

<end panel>

<define panel> “brown cow”

-   -   Mooo!

<end panel>

The script file includes a sequence “cow sequence” which ties togethertwo panels “how now” and “brown cow”, which are defined latter in thescript file. As will be apparent to those having skill in the art,script files are composed of a plurality of commands and definitions ina high level scripting language. Script files are conventionallygenerated with some type of text editor.

More details regarding the guidance interface itself may be obtainedfrom the following commonly assigned patents and patent applications,the disclosures of which are incorporated herein in their entirety: U.S.Pat. Nos. 5,428,731; 5,469,540 and 5,488,685; Ser. No. 08/010,063 filedon Jan. 27, 1993 by Palmer et al. entitled “Method and Apparatus forProviding a Help Based Window System Using Multiple Methods”; Ser. No.08/010,061 filed On Jan. 27, 1993 by Coleman et al. entitled “Method andApparatus for Displaying and Scrolling Data in a Window-Based GraphicUser Interface”; Ser. No. 08/056,367 filed on Apr. 30, 1993 by Brewer etal. entitled “Method and Apparatus for Generating and Displaying VisualCues on a Graphics User Interface”.

B. Guidance Editor

The above described user guidance information is created using theediting and compiling system illustrated in FIG. 14. A functionaloverview of the system will be presented first, followed by a detaileddiscussion of the principal editors.

B.1 Overview

As illustrated, editor (168) includes a plurality of interrelatededitors. The editors include a command editor (172) for receiving anddisplaying a list of script file statements, a graphical sequence editor(176) for creating or modifying a sequence of interconnected guidancepanels (and other objects); an access editor for creating or modifyingan access window (e.g. such as window 62 in FIG. 2); a panel editor forcreating or modifying a user guidance panel (e.g. such as the panelillustrated in FIG. 4); an index editor for creating or modifying indexentries (such as those illustrated in area (86) of FIG. 5); and aneditor recording module (192) for logging the editing operationsperformed by any one of the previously mentioned editors.

A script file may be input to the editor (168) in several differentways. For instance, the user can create a new script file using a “New”command under a “File” pull down menu (not shown) in the menu bar (32)of FIG. 1. Second, the user can open a previous saved editor script fileusing an “Open” command in the “File” pull down menu (not shown) in themenu bar (32). Third, the user may import an existing script source fileusing an “Import” command under the “File” pull down menu (not shown) inthe menu bar (32).

A script file which was created by a text editor must be converted toparse tree format before loading into the editor. To this end, thescript file (138) is sent to a text converter (142) and decompiler (146)for conversion from text editor format to object-oriented parse treeformat (to be described below). Once in parse tree code format, the filemay be loaded into editor (168).

Once a source file has been properly loaded, the document appears in thecommand editor. The command editor (e.g. FIGS. 15 and 16) displays alist of commands (187) contained in the script file in a scrollingwindow. However, only top level commands are displayed, such as <DefinePanel> commands or <Define Sequence> commands. Any component objectswithin this list are embedded in the sequences and panels and are notshown.

The user may scroll through the list and choose a command which requiresediting. For instance, the user may select a specific sequence entry inthe script file by pointing to the sequence entry in the list. Doubleclicking on the sequence evokes the sequence editor (176).

Presuming a specific editor has been selected, the user then proceeds toperform editing. According to a particularly beneficial aspect of thepresent invention, all of the editors are interconnected andinterrelated, such that the user can access any editor from any othereditor. For instance, the user may start by invoking the sequence editor(176) which graphically lists a sequence of icons representing thecomponents of a sequence. One or more of the components within thesequence may comprise panel icons representing panels in the sequence.By clicking on the panel icons a panel editor (184) is invoked.Furthermore, by “clicking” on a word in a text object in a panel in thepanel editor, that word is added to the index for the current sequence.

The different editors allow the user to review a script program in avariety of different representations. If a user makes modifications tothe script program in a particular representation, the system mayautomatically make corresponding changes in other representations. Forexample, if a user alters the script program using the graphicalrepresentation employed by the sequence editor, the system will makecorresponding changes to the individual lines of script code, which maybe reviewed using a text editor. In one embodiment, both graphical andtextual representations may be presented simultaneously on the graphicsdisplay (using different windows, for instance). This allows the user toreview, in real-time, how changes made in the sequence editor affect thetext of the script program.

For example, FIG. 31A illustrates two windows which respectively displaythe textual and graphical representations of the relatively simplescript file described previously. This script file comprises a sequenceof two panels “how now” and “brown cow”, whose icons are labelled HN andBC in the graphical representation. During editing, the user may desireto switch the order of the two panels. This can be done in the graphicalrepresentations by dragging and dropping one of the panel icons. Theresult of such an operation is shown in FIGS. 31B and 31C. When thescript file is edited in the graphical mode, the resulting changes areautomatically implemented in the textual mode as well, as shown in FIG.31C. In this particular situation, the changes are carried out in thesequence editor 176, and the corresponding representations in the twomodes are linked to one another. Thus, as the user moves and releasesthe icon HN to follow the icon BC in the sequence, the correspondinglines in the textual script are also moved.

Once the user has finished editing or creating the guidance informationfile, the user closes out the relevant editor. The editor interface willthen instruct the compiler (146) via connection (163) to recompile theinformation file, but only with respect to the portions that wereamended. The recompiled portion is then added to the remainder of theparse tree file in a memory (150). If an error is detected during therecompiling process, the offending text is placed inside a filerepresented by a visual error indicator, such as a “bug” icon (240) ofFIG. 18. Compilation then continues until the end of the file isreached. At this time, double clicking on the bug icon will display theoffending text, which may then be edited and corrected. This correctedportion is then recompiled. If successful, the bug icon is extinguished.This process greatly improves the efficiency of program creation. In theprior art, an error in the compiling process would typically require theentire file to be recompiled.

If the user wishes to convert the parse tree file back to a text editorformat (159), he may decompile the file using decompiler (154) and textconverter (160). For instance, the user may desire to use the scriptfile in an application that requires that the file be in a text editorformat. More specifically, a document may be exported using an “Export”command contained within the “File” pull down menu (not shown) of menubar (32).

B.2 Command Editor and the Parse Tree Format

The command editor serves as an initial gateway through which othereditors may be accessed. The command editor, as illustrated in exemplaryFIGS. 15 and 16, is initially invoked when the user loads a file inparse tree code format into the editor (168). The command editorresponds to the loading of the file by displaying an annotated list ofstatements (187) contained within the script file in window (185). Inthe specific embodiment in FIG. 15, the script file contains threedefine sequence statements (a), (b) and (c), and three define panelstatements (x), (y) and (z). Each of these statements may includeassociated embedded script information. However, only the “top” or“main” commands are displayed to facilitate rapid review of the scriptfile. By way of illustration, the command editor would not display theindented information under any of the main <define sequence> and <definepanel> commands illustrated in the sample script program of FIG. 27. Itshould be noted that the statements (187) included in window (185) arenot intended to represent any type of presentation format or syntax. Thestatements have been shown in generic format to so as not to obfuscatethe discussion with unnecessary detail.

To further facilitate review of the script file, the command editor can,at the request of the user (e.g. by appropriate menu selection)reorganize the information within the command window. The commands maybe sorted, such that all of the <define sequences> are displayed first,followed by all of the <define panels>. This is illustrated in FIG. 16.Alternatively, upon the command of the user via appropriate menuselection, the command editor can filter the file by only presentingcertain types of program elements (not illustrated).

As mentioned, once the editor (168) is closed, the script program whichwas modified is recompiled to parse code format. The conversion may bebest understood with reference to FIGS. 27-30.

An exemplary parse tree is illustrated in FIG. 27 corresponding to theabove described script file (340). Each definition block of the script(340) is broken into corresponding blocks (344), (348) and (352). Asshown in FIG. 28, the topmost block (344) is enlarged for discussionpurposes. As shown there, the <define sequence> and <panel> statementtokens (356) and (368) have appended thereto statement IDs (360) and(372). These statement IDs are useful in tracking changes made in ascript source file from one revision to the next, as will be discussedin connection with the Localization Tool. The actual textual objectsassociated with the compiled statements are indicated as objects (364)and (376) respectively. FIGS. 29-30 show an enlarged view of theremainder of the script parse tree. The parse tree elements in FIGS.29-30 are based on the same organizational premise identified withrespect to FIG. 27.

Furthermore, the internal format of the parse tree is tokenized. Stringsthat are repeated in the source are factored into a single string in atable. Occurrences of the string are replaced with token IDs whichrequire less space.

B.2 Sequence Editor

The sequence editor allows the user to graphically define therelationship between the component objects of a particular guidance helpsequence by stringing together a series of icons representing thecomponents.

As illustrated in FIG. 17, the components of a particular guidance helpsequence may include a series of panel objects (204), (224), (228),(216) and (232). For example, panel object (204) might correspond to thespecific panel shown in FIG. 4. Other sequence objects correspond tomodules of script code, each of which preferably implements a commondisplay interface function. These modules are referred to as “plug-ins”.For example, plug-in (212) defines a series of control statements whichmay carry out the common interface routine where a user is queried “Areyou sure you want to continue?”. Plug-in (208) implements an “if”program statement, while plug-in (220) defines a “skip-if” programfunction. Plug-in (200) allows the programmer to attach a comment to thesequence, which may for example present an overview of the functionalityof the sequence. Last, plug-ins (196) and (236) define the beginning andend of the sequence.

The above listing of plug-ins is obviously exemplary in nature. It willbe apparent to practitioners in the art that other types of plug-inswill be useful. In fact, the individual user may maintain a customizedlist of plug-ins providing the panels and script modules which he or sheuses most often. This customized list may be associated with thesequence editor shortcuts folder icon (264) shown in FIG. 19, or whoseopened contents are illustrated in FIG. 20.

In operation, the user may string together a series of panels (e.g. 224,228, etc) and script plug-in modules (e.g. 208, 212, etc.) using thegraphical interface of the sequence editor. For example, if apre-existing sequence is displayed, the user can add to the sequence bydragging icons from the sequence editor shortcut panel window (264) tothe sequence of icons in the sequence editor. More specifically, supposethat at the time the user started editing, only icons (196), (200),(204) and (208) were in place. At this time the rightmost icon (208)defining an “if” statement would include two “wires” emanatingtherefrom. To add to the sequence, the user may access the shortcutwindow (264) and drag desired icons (representing panels or shortlistings of script code) to the sequence editor screen. The user wouldthen “drop” the icons onto the terminal ends of the “wires” emanatingfrom the “if” statement.

According to particularly beneficial features of the present invention,the user may use the graphical sequence editor as a springboard toperform further editing on individual display plug-ins within thesequence. For instance, the sequence shown in FIG. 17 includes aplurality of panel objects (204), (224), (228), (216) and (232). Byclicking on any on of these modules the user invokes the panel editor(to be discussed below), whereupon the user can performing editing onthe panel display objects.

Alternatively, the sequence editor may interface with the index editor(to be discussed below) through appropriate menu command. This willevoke an index editor window (280 as shown in FIG. 21) showing indexterms relating to the displayed sequence. The index editor interfacewill be discussed further below.

B.3 Panel Editor

The panel editor allows the user to edit an existing panel using aseries of three windows. As used herein, the term “panel” refers to adata set associated with a display presentation, an example of which isillustrated as panel (74) in FIG. 4. The first of the three windows, the“Panel Palette Window”, allows creation of new elements in the sequence.Specifically this window allows for the creation of all of the elementsassociated with a panel, including (but not limited to) title, textobjects, graphical objects, video sequences, radio buttons, check boxes,picture buttons, and the like.

The second window is referred to as the “panel window”. An exemplarypanel window (284) is illustrated in FIG. 22. As shown, the layout ofthe panel window is similar in appearance to the window which ispresented to the user during the user guidance dialogue. In other words,the editor employs WYSIWYG (what-you-see-is-what-you-get) format toperform editing. Clicking on any text object within the panel enables auser to edit the object. For instance the user in FIG. 22 hashighlighted the word “computer” (288) in the text box (292). The usermay then modify the text, resize the text or move the text to adifferent location.

Other display objects within the panel display may be edited in ananalogous fashion. Double clicking a button brings up a window to editthe event associated with that button. Double clicking on a picturebrings up a graphical object window. Dragging a graphical object from agraphical object window to a panel replaces the existing graphicalobject in the panel with the new graphical object from the objectwindow. Similarly, dragging a coach mark from a coach mark object windowto a panel attaches that coach mark to the panel.

If the panel happens to be a shared panel (as discussed above), thenchanges to the shared panel occur globally to all panels. The sharedpanel preferably has a different color in the window's title bar toremind the author that this is a shared panel. If the user is notcertain whether a panel is shared, he may investigate this matterthrough the panel editor interface, which identifies shared objects.

Last, the third window in the panel editor interface provides for theediting of events associated with a panel (e.g. create a panel, showpanel, close panel, etc.).

B.4 Access Editor

FIG. 25 illustrates the access editor, which allows the user to edit theaccess window (320) for the guidance file. This interface allows a userto change all global database properties affecting, a database. Inoperation, the user activates a “Get Database Properties” menu item,causing the CPU (16) to present a dialog box. The user may selectvarious global data base properties through the dialog box.

Clicking on any text object in the access window (320) allows the userto edit that object. Dragging a graphical object from the graphicalobject window to a graphical object in the access window replaces theexisting graphical object with the new graphical object.

To reorder the sequences in the sequence list, the user may drag thesequence to the desired location. To reorder the headers in the sequencelist; the user may drag the header to the desired location. To reorderthe topics in the topic area list, the user may drag the topic area tothe desired location.

To create a new sequence the author chooses a “New Sequence” menu entry(not shown) from the menu bar. A default sequence with one panel is thencreated, from which the user may then modify and build upon. To create anew header the author chooses a “New Header” menu entry (not shown) fromthe menu bar.

B.5 Index Editor

The index editor (312) allows the author to edit individual entries inthe index of the guidance file. As shown in FIG. 23, the index terms arelisted in the scrollable region of window (312) located beneath thelegend “index term”. The arrows (300) to the right of the index termsallow the author to view synonyms for the index term. That is, byclicking on an arrow, the user is presented with synonyms for theassociated index term. The column to the right of the index terms lists“hidden names”. Hidden names are used in a variety of contexts, such asin storing Japanese index terms. Japanese text may by represented inKanji notation or in phonetic notation. Thus for an index term in Kanjinotation, a hidden name for the index may be defined as its phoneticequivalent. This is useful as often different forms of Chinesecharacters are difficult to manipulate using a computer. Themanipulation is performed on a more manipulable counterpart to theindex, such as its phonetic equivalent.

To add an index term, the author selects a “New Index” menu item (notshown) from a menu bar. To edit a hidden name, the author clicks on thehidden name. The word “none” in italics indicates that there is nohidden name. To add a synonym, the author selects the index term andchooses a “New Synonym” menu item (not shown). To delete a hidden name,index or synonym, the author selects the term by clicking and then hitsthe delete key.

The user may associate an index term with a particular sequence bydragging an index term from an object window to the appropriate sequencein a sequence object window. Alternatively, the user may create theassociation by dragging the sequence term from its object window to theappropriate index term in its index object window.

By “clicking” on a word in a text object in a panel in the panel editor,that word is added to the index for the current sequence. If the authorclicks on a selection of words, then that selection becomes an indexentry. The author may also drag a text selection from a panel editorwindow to an index editor window, and the appropriate index terms willbe created.

To view what sequences are connected to an index, the user may choosethe “Related Objects” menu entry. A window (316) will appear listing theindex entries which are associated with a main index, as shown in FIG.24. The user may remove an assignment of an index to a sequence byselecting the sequence and choosing a “Remove Index” menu entry (notshown).

The index editor can be used to generate index terms for every item in asequence or database by using a “Generate Index” menu entry (not shown).In response to activating this command, the index editor will add anindex term for every word in the sequence or database. The user mayspecify a stop word list which specifies words that are not to beincluded in the index. Words in the sequence are compared with words inthe stop list, and not assigned an index term if they match a word inthe stop list.

B.6 Localization Tool

A further beneficial feature of the present invention, although notillustrated in FIG. 14, is the localization tool. As shown in FIG. 26,this tool allows the user to update a foreign message help guidancedatabase in response to a prior (old) U.S. panel (324), a new U.S. panel(328), and the prior (old) foreign panel (332). The general goal is tocreate a new foreign panel (336) which models the change between the oldU.S. panel (324) and the new U.S. panel (328).

In operation, the user may invoke the localization tool through thecommand editor interface (such as by clicking on a menu entry devoted tothe localization tool). In response thereto, the CPU (16) generates thewindow illustrated in FIG. 26 with text areas (324), (328), (332) and(336) initially empty. The user may then load particular source guidancefiles corresponding to “old US”, “new US” and “old loc”. The file “oldUS” corresponds to an original source file with textual material in theEnglish language, while the file “old loc” corresponds to an originalsource file with textual material in some language other than English,such as French. The file “new US” corresponds to a subsequent revisionof the “old US” document. As mentioned the general goal is to compare,for each textual message, the “old US” file with the “new US” file.Changes should be made in the “new loc” file which correlate with thenature of the change made in the “new US” file. This process is referredto as localization. A user who performs this task is referred to as alocalizer.

The localization tool performs its comparison between U.S. and foreignfiles by matching statements which share the same IDs. As shown in FIGS.26-28, each statement in a source file produced by the present inventionincludes a statement ID (e.g. 372 in FIG. 28). The user may sequencethrough different commands by activating the “Prev” and “Next” commandsshown in the upper right-hand corner of FIG. 26. The button “Hide LocInfo” allows the user to display only the top block of the localizationwindow (e.g. thereby not displaying the U.S. and loc. files).

As a matter of practice, however, different situations will arise thatmake it difficult to determine what textual statement to use in the “newloc” window. For example, there may be a textual entry for a statementin the “new US” file, but not in the “old US” file. To cope with theseproblems, the present invention identifies various permutations whichmay occur between the three input documents (e.g. “old US”, “new US”,and “old loc”) and decides what information to include with the “newloc” database.

More specifically, the different permutations which may occur areidentified with the table below:

New U.S. Old U.S. Permutation exists? Comparison exists? Old Loc. 1 yes= yes yes 2 yes ≢ yes yes 3 no yes yes 4 yes no yes 5 no no yes 6 yes =yes no 7 yes ≢ yes no 8 no yes no 9 yes no no

Permutation 1 (e.g. event 1) represents the best case scenario. Anobject exists in both the new U.S. and old U.S. databases and has notchanged at all. Also, a representation of that object exists in the oldlocalized version of the file. In this situation, the old localizedversion is automatically copied to the new localized version of thefile, as illustrated in FIG. 26.

Permutation 2 represents the situation where an object has changed fromthe old U.S. to the new U.S. versions of the file, and the old localizedversion has a representation of the object. In this situation the oldlocalized version is copied, and is flagged as a “wild guess” newlocalized version of the file. The user is informed that thelocalization tool is unsure about its decision by displaying “WildGuess” above the window (336), as illustrated in FIG. 26. The user maythen make the final decision regarding the propriety of the localizationtool's decision.

Permutation 3 represents the situation where an object is deleted fromthe database in the new U.S. file. That is, it is present in the oldU.S. and the old localized versions of the file, but is not present inthe new U.S. version. In this situation, nothing is copied to the newlocalized version.

Permutation 4 represents a situation where an object exists in the newU.S. version and in the old localized version, but not in the old U.S.version. In this case, the corresponding object in the old localizedversion is copied to the new localized version and is flagged as a “wildguess”.

Permutation 5 represents the situation where an object exists in the oldlocalized version but is not present in either the new U.S. version orthe old U.S. version. This object was presumably added by the localizerwho generated the old localized version. In this situation nothing iscopied to the new localized file.

Permutation 6 represents the situation where an object exits in the newU.S. version and in the old U.S. version, but not in the localizedversion. The two representations of the object are identical. In thissituation the object in the new U.S. version is copied to the newlocalized version, and is flagged as “previously deleted”. Thisindicates that the object was deleted by the localizer before andprobably will need to be deleted again when the localizer is addingfinishing touches.

Permutation 7 is identical to permutation 6 except that the tworepresentations of the object are not identical in the U.S. files. Inthis situation, the object in the new U.S. version is copied to the newlocalized version, and is flagged as “previously deleted”.

Permutation 8 represents the situation where an object exists only inthe old U.S. version. Nothing is copied to the new localized version.

Permutation 9 represents the situation where a new object has been addedand appears only in the new U.S. version. The object is copied to thenew localized version and is flagged as “new”.

B.7 Recording Module

The recording module (192) preferably logs all of the revisions made inany of the other editors. For instance, suppose a French localizer hasspent several hours converting the textual messages in a U.S.application guidance help file to their French counterpart. If therecording module is activated, it will track and log all of themodifications made by the French localizer. This information is storedas a script file which can be run to repeat the series of events duringthe French localizer's editing session.

Now assume that another localizer seeks to convert the U.S. file toanother language, such as Spanish The Spanish localizer may run a scriptfile created by the French localizer, thereby automatically repeatingthe same operations performed by the French operator. This offers greatpotential in reducing the workload of the second Spanish localizer. Therecording module may be implemented using an Apple Script recordingmodule, as described in Inside Macintosh, by Apple Computer, Inc.However, it will be apparent that other commercially available recordingmodules may be used.

The attached appendix lists internal data structures to the userguidance editor interface. For instance, the data structures are used bypanel editor and the sequence editor to manipulate script source.

The above-described exemplary embodiments are intended to beillustrative in all respects, rather than restrictive, of the presentinvention. Thus the present invention is capable of many variations indetailed implementation that can be derived from the descriptioncontained herein by a person skilled in the art. All such variations andmodifications are considered to be within the scope and spirit of thepresent invention as defined by the following claims.

In particular, the present invention has been discussed in terms of helpguidance information to facilitate discussion. However, it will beapparent to one having ordinary skill in the art that the principlesdisclosed herein are applicable to other programming and editingenvironments.

APPENDIX void InitializeKublai( void ); void DestructKublai( void );TLinkedList* GetParseTree( void ); char* FunctionCallParamToText( constTFunctionCallParam &fnCall ); TextObj* DuplicateTextObj( const TextObj&textObj ); class TStatement: public TLinkedListElement {  public:  longfStatementToken;  TLinkedList* fParameterList;  TLinkedList*fContainedStatements;  TextObjP fCommentAtEndOfLine;  TStatement( longstatementToken );  ~TStatement( void );  TObject* Clone(void) throw( );}; class TParameter: public TLinkedListElement {  public: ~TParameter(void);  TLinkedList* fContaimedParameters;  TObject*Clone(void) throw( );  TLinkedList* DuplicateContainedParams(void)throw( ); }; class TStringParam: public TParameter {  public:  char*fString;  TStringParam( char* string );  ~TStringParam( void ); TObject* Clone(void) throw( ); }; class TFunctionCallParam: publicTParameter {  public:  char* fFunctionName;  TFunctionCallParam( char*functionName );  ~TFunctionCallParam( void );  TObject* Clone(void)throw( ); }; class TIntegerParam: public TParameter {  public:  longfInteger;  TIntegerParam( long a );  TObject* Clone(void) throw( ); };class TOSTypeParam: public TParameter {  public:  OSType fOSType; TOSTypeParam( OSType a );  TObject* Clone(void) throw( ); }; classTKeywordParam: public TParameter {  public:  long fKeyword; TKeywordParam( long a );  TObject* Clone(void) throw( ); }; classTNullParam: public TParameter {  public:  TObject* Clone(void) throw( );}; class TRGBColorParam: public TParameter {  public:  RGBColorfRGBColor;  TRGBColorParam( RGBColor a) { fRGBColor = a; };  TObject*Clone(void) throw( ); }; class TColumnParam: public TParameter { public:  long fTop;  long fLeft;  long fRight;  TColumnParam( long top,long left, long right );  TObject* Clone(void) throw( ); }; classTPointParam: public TParameter {  public:  Point fPoint;  TPointParam(Point a ) { fPoint = a; };  TObject* Clone(void) throw( ); }; classTRectParam: public TParameter {  public:  Rect fRect;  TRectParam( Recta ) { fRect = a; };  TObject* Clone(void) throw( ); }; classTRedArrowParam: public TParameter {  public:  long fStart;  long fEnd; TRedArrowParam( long start, long end );  TObject* Clone(void) throw( );}; class TStyledStringParam: public TParameter {  public:  TextObjPfStyledString;  TStyledStringParam( TextObjP styledString ); ~TStyledStringParam(void);  TObject* Clone (void) throw( ); }; classTOrParam: public TParameter {  public:  TParameter* fLeft;  TParameter*fRight;  TOrParam( TParameter* left, TParameter* right ); ~TOrParam(void);  TObject* Clone(void) throw( ); }; class TAndParam:public TParameter {  public:  TParameter* fLeft;  TParameter* fRight; TAndParam( TParameter* left, TParameter* right )  ~TAndParam(void); TObject* Clone(void) throw( ); }; class TNotParam: public TParameter { public:  TParameter* fCondition;  TNotParam( TParameter* condition ); ~TNotParam(void);  TObject* Clone(void) throw( ); };

1. A method for generating computer program files using a computer,including the steps of: forming a parse tree representation of acomputer program file as a sequence of interconnected components, eachof the components being respectively associated with at least onecomponent editor among a plurality of component editors based on anattribute of the corresponding component, the plurality of componenteditors each being configured to perform a corresponding one of aplurality of editing functions based on a component attribute with whichthe corresponding component editor is respectively associated; modifyinga portion of said program file in said parse tree format by a usergraphical interaction using a graphical editor to manipulate placementof at least one of the components and create a modified program portionin which the sequence of interconnected components are re-sequenced andrelinked based on the user-manipulated placement of the at least one ofthe components; displaying the at least one component editorcorresponding to the at least one of the components in the modifiedprogram portion to enable the user to edit the at least one of thecomponents with the corresponding component editor; determining aremainder of said parse tree program file containing each componentamong the interconnected components not dependent on said modifiedprogram portion; compiling only said modified program portion into saidparse tree format, while maintaining said determined remainder of saidparse tree program file in an unmodified state; and re-forming the parsetree representation of said computer program file by integrating saidmodified and compiled program portion into said determined remainder ofsaid parse tree program file that is maintained in the unmodified state.2. The method of claim 1, wherein said modifying comprises the step of:selecting a sequence editor interface for displaying a graphicalrepresentation of a sequence of interconnected components includedwithin said program file.
 3. The method of claim 2, wherein saidcomponents are represented by graphical icons that are placed in thesequence of interconnected components through the user graphicalinteraction.
 4. The method of claim 2, wherein said components includeat least one panel component, said panel component defining at least onegraphical window display.
 5. The method of claim 4, further includingthe step of: selecting said at least one panel component to invoke apanel component editor interface for editing said least one said panelcomponent; and editing said at least one panel component using saidpanel component editor interface.
 6. The method of claim 2, wherein saidcomponents include at least one computer code component, said computercode component including at least one program statement.
 7. The methodof claim 6, further including the steps of: selecting at least one saidcomputer code component to display said at least one program statementwithin said computer code component; and editing said computer codecomponent.
 8. The method of claim 2, further including modifying saidgraphical representation of said sequence by performing the followingsteps: accessing a component file containing a plurality of components;selecting at least one component from among the plurality of componentscontained in the accessed component file; instructing said computer toadd said at least one component to said representation of said sequence.9. The method of claim 8, wherein said selecting and instructing stepsinclude: dragging a graphical representation of said at least onecomponent from said component file to said graphical representation ofsaid sequence; and dropping said graphical representation of said atleast one component onto said graphical representation of said sequence,to incorporate said graphical representation of said at least onecomponent into said graphical representation of said sequence.
 10. Themethod of claim 1, further comprising the steps of: selecting a paneleditor interface; selecting a panel window contained within saidcomputer program file; displaying a representation of said panel window;and editing said panel window.
 11. The method of claim 10, wherein saidediting of said panel window comprises the step of: changing at leastone display object associated with said panel window.
 12. The method ofclaim 1, further comprising the step of: selecting an index editorinterface for displaying index terms included within said program file;and editing at least one of said index terms.
 13. The method of claim 1,wherein said step of compiling said modified program portion comprisesthe steps of: storing sections of said program portion which thecompiler failed to compile due to error; informing a user of thepresence of said sections which failed to compile; said user correctingsaid sections which failed to compile; and said user recompiling saidcorrected sections.
 14. The method of claim 13, wherein said sectionswhich failed to compile are associated with a graphical icon, and saiduser initiates said correcting of said sections by activating saidgraphical icon.
 15. The method of claim 1, wherein changes made to aportion of said program file in said parse tree format using thegraphical editor are substantially simultaneously depicted incorresponding portions of said computer program file presented in a textinterface.
 16. The method of claim 1, wherein a text of said modifiedprogram portion which fails to compile is associated with anerror-indicating graphical icon for activation by a user to display saidtext associated with said error-indicating graphical icon for editingand correction by the user for recompilation.
 17. The method of claim 1,wherein the manipulation of placement of the at least one of thecomponents includes dragging and dropping the at least one of thecomponents via the graphical editor.
 18. A computer editor forgenerating computer program files using a computer, comprising: an inputdevice for inputting a program file in a parse tree format into saidcomputer editor, said program file including at least one sequence, saidat least one sequence including at least one component; a graphicalinterface for graphically displaying said at least one sequence and itsconstituent at least one component; an editing interface for accessing adatabase including a stored library of components; a selection andmoving means for selecting and moving by dragging and dropping at leastone of said stored library of components to said at least one graphicalsequence for placement by a user graphical interaction, each of saidcomponents being respectively associated with at least one componenteditor among a plurality of component editors based on an attribute ofthe corresponding component, the plurality of component editors eachbeing configured to perform a corresponding one of a plurality ofediting functions based on a component attribute with which thecorresponding component editor is respectively associated; adding meansfor integrating said selected at least one of said stored library ofcomponents with said at least one sequence to form a modified sequenceof interconnected components reconfigured and relinked based on the userplacement; component editor displaying means for displaying the at leastone component editor corresponding to said selected at least one of saidstored library of components in said modified sequence to enable a userto edit said selected at least one of said stored library of componentswith the corresponding component editor; determining means fordetermining a remainder of said program file containing each componentamong the interconnected components not dependent on said modifiedsequence; compiling means for compiling only said modified sequence,while maintaining said determined remainder of said program file in anunmodified state; integrating means for integrating said modifiedsequence into said determined remainder of said program file, to re-formthe parse tree format of said program file based on said modifiedsequence integrated into said determined remainder of said program filethat is maintained in the unmodified state; and a text interface fordisplaying a textual representation of at least a portion of saidintegrated program file; wherein said text interface is invokedsimultaneously with said graphical interface to textually andgraphically represent changes based on the user graphical interaction,and wherein changes made to said at least one sequence in said graphicalinterface by dragging and dropping are substantially simultaneouslydepicted in corresponding portions of said program file presented insaid text interface.
 19. The computer editor of claim 18, wherein saidcomponents are associated with a graphical icon, and wherein saidselection and moving means drags an icon associated with said at leastone stored library component to said graphical sequence.
 20. Thecomputer editor of claim 19, wherein said adding means drops said iconassociated with at least one stored library component onto saidgraphical sequence, to integrate said at least one stored librarycomponent into said graphical sequence.
 21. The computer editor of claim18, comprising associating means for associating a text of said modifiedsequence of interconnected components which fails to compile with anerror-indicating graphical icon for activation by a user to display saidtext associated with said error-indicating graphical icon for editingand correction by the user for recompilation.
 22. A computer programproduct stored on a computer-readable medium for use in association witha computing device with a graphical display, comprising: an input modulefor inputting a program file in a parse tree format into said computingdevice, said program file including at least one sequence, said at leastone sequence including at least one component; a graphical module forgraphically displaying said at least one sequence and its constituent atleast one component; an editing interface module for accessing adatabase including a stored library of components; a selection andmoving module for selecting and moving by dragging and dropping at leastone of said stored library of components to said at least one graphicalsequence for placement by a user graphical interaction, each of saidcomponents being respectively associated with at least one componenteditor among a plurality of component editors based on an attribute ofthe corresponding component, the plurality of component editors eachbeing configured to perform a corresponding one of a plurality ofediting functions based on a component attribute with which thecorresponding component editor is respectively associated; an addingmodule for integrating said selected at least one of said stored libraryof components with said at least one sequence to form a modifiedsequence of interconnected components reconfigured and relinked based onthe user placement; a component editor displaying module for displayingthe at least one component editor corresponding to said selected atleast one of said stored library of components in said modified sequenceto enable a user to edit said selected at least one of said storedlibrary of components with the corresponding component editor; adetermining module for determining a remainder of said program filecontaining each component among the interconnected components notdependent on said modified sequence; a compiling module for compilingonly said modified sequence, while maintaining said determined remainderof said program file in an unmodified state; an integrating module forintegrating said modified sequence into said determined remainder ofsaid program file, to re-form the parse tree format of said program filebased on said modified sequence integrated into said determinedremainder of said program file that is maintained in the unmodifiedstate; and a text module for displaying a textual representation of atleast a portion of said integrated program file; wherein said textmodule is invoked simultaneously with said graphical module to textuallyand graphically represent changes based on the user graphicalinteraction, and wherein changes made to said at least one sequence insaid graphical module by dragging and dropping are substantiallysimultaneously depicted in corresponding portions of said program filepresented in said text module.
 23. The computer program product of claim22, wherein said components are associated with a graphical icon, andwherein said selection and moving module drags an icon associated withsaid at least one stored library component to said graphical sequence.24. The computer program product of claim 23, wherein said adding moduledrops said icon associated with at least one stored library componentonto said graphical sequence, to integrate said at least one storedlibrary component into said graphical sequence.
 25. The computer programproduct of claim 22, comprising an associating module for associating atext of said modified sequence of interconnected components which failsto compile with an error-indicating graphical icon for activation by auser to display said text associated with said error-indicatinggraphical icon for editing and correction by the user for recompilation.26. A computer-readable recording medium containing programming coderecorded thereon that causes a computer to generate computer programfiles, the computer, when executing the programming code, beingconfigured to implement procedures comprising: forming a parse treerepresentation of a computer program file as a sequence ofinterconnected components, each of the components being respectivelyassociated with at least one component editor among a plurality ofcomponent editors based on an attribute of the corresponding component,the plurality of component editors each being configured to perform acorresponding one of a plurality of editing functions based on acomponent attribute with which the corresponding component editor isrespectively associated; modifying a portion of said program file insaid parse tree format by a user graphical interaction using a graphicaleditor to manipulate placement of at least one of the components andcreate a modified program portion in which the sequence ofinterconnected components is re-sequenced and relinked based on theuser-manipulated placement of the at least one of the components;displaying the at least one component editor corresponding to the atleast one of the components in the modified program portion to enablethe user to edit the at least one of the components with thecorresponding component editor; determining a remainder of said parsetree program file containing each component among the interconnectedcomponents not dependent on said modified program portion; compilingonly said modified program portion into said parse tree format, whilemaintaining said determined remainder of said parse tree format programfile in an unmodified state; and re-forming the parse treerepresentation of said computer program file by integrating saidmodified and compiled program portion into said determined remainder ofsaid parse tree program file that is maintained in the unmodified state.27. The medium of claim 26, wherein said procedure of modifyingcomprises: selecting a sequence editor interface for displaying agraphical representation of a sequence of interconnected componentsincluded within said program file.
 28. The medium of claim 27, whereinsaid components are represented by graphical icons that are placed inthe sequence of interconnected components through the user graphicalinteraction.
 29. The medium of claim 27, wherein said components includeat least one panel component, said panel component defining at least onegraphical window display.
 30. The medium of claim 29, further includingthe procedures of: selecting at least one said panel component to invokea panel editor interface for editing said least one said panelcomponent; and editing said at least one panel component using saidpanel component editor interface.
 31. The medium of claim 27, whereinsaid components include at least one computer code component, saidcomputer code component including at least one program statement. 32.The medium of claim 31, further including the procedures of: selectingat least one said computer code component to display said at least oneprogram statement within said computer code component; and editing saidcomputer code component.
 33. The medium of claim 27, further includingmodifying said graphical representation of said sequence by performingthe following procedures: accessing a component file containing aplurality of components; selecting at least one component; andinstructing said computer to add said at least one component to saidrepresentation of said sequence.
 34. The medium of claim 33, whereinsaid selecting and instructing procedures include: dragging a graphicalrepresentation of said at least one component from said component fileto said graphical representation of said sequence; and dropping saidgraphical representation of said at least one component onto saidgraphical representation of said sequence, to incorporate said graphicalrepresentation of said at least one component into said graphicalrepresentation of said sequence.
 35. The medium of claim 26, furthercomprising the procedures of: selecting a panel editor interface;selecting a panel window contained within said computer program file;displaying a representation of said panel window; and editing said panelwindow.
 36. The medium of claim 35, wherein said procedure of editing ofsaid panel window comprises the procedure of: changing at least onedisplay object associated with said panel window.
 37. The medium ofclaim 26, further comprising the procedures of: selecting an indexeditor interface for displaying index terms included within said programfile; and editing at least one of said index terms.
 38. The medium ofclaim 26, wherein said procedure of compiling said modified programportion comprises the procedures of: storing sections of said programportion which the compiler failed to compile due to error; informing auser of the presence of said sections which failed to compile; said usercorrecting said sections which failed to compile; and said userrecompiling said corrected sections.
 39. The medium of claim 38, whereinsaid sections which failed to compile are associated with a graphicalicon, and said user initiates said correcting of said sections byactivating said graphical icon.
 40. The medium of claim 26, whereinchanges made to a portion of said program file in said parse tree formatusing the graphical editor are substantially simultaneously depicted incorresponding portions of said computer program file presented in a textinterface.
 41. The medium of claim 26, wherein the programming codecauses the computer to associate a text of said modified program portionwhich fails to compile with an error-indicating graphical icon foractivation by a user to display said text associated with saiderror-indicating graphical icon for editing and correction by the userfor recompilation.
 42. The medium of claim 26, wherein the manipulationof placement of the at least one of the components includes dragging anddropping the at least one of the components via the graphical editor.